home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archives / ForCLI / wsz13.lzh / wsz.c < prev    next >
C/C++ Source or Header  |  1992-09-18  |  15KB  |  774 lines
  1.  
  2. #include <intuition/intuition.h>
  3. #include <intuition/intuitionbase.h>
  4. #include <dos/dos.h>
  5. #include <exec/memory.h>
  6. #include <exec/ports.h>
  7.  
  8. #define NUMBER    1
  9. #define LLETTER 2
  10. #define ULETTER 3
  11. #define OTHER    4
  12.  
  13.  
  14. struct IntuitionBase *IntuitionBase = NULL;
  15. struct DOSBase         *DOSBase        = NULL;
  16.  
  17. struct Window *window;
  18. struct Screen *screen;
  19.  
  20. struct Com
  21. {
  22.     struct  Com *Next;
  23.     struct  Com *Prev;
  24.     LONG    Command;
  25.     LONG    Arg;
  26.     LONG    Arg2;
  27. } *Start = NULL, *End = NULL, *Tmp = NULL;
  28.  
  29. char ver[]="\0$VER: WSZ 1.3 (92.09.18)";
  30.  
  31.  
  32. /*
  33. ** Closes down, and exits.
  34. */
  35. void cldo(int err)
  36. {
  37.     if(DOSBase)         CloseLibrary(DOSBase);
  38.     if(IntuitionBase)   CloseLibrary(IntuitionBase);
  39.     exit(err);
  40. }
  41.  
  42.  
  43. /*
  44. ** Opens up all needed libraries and stuff.
  45. */
  46. void opup()
  47. {
  48.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
  49.     if(!IntuitionBase) cldo(30);
  50.  
  51.     DOSBase = (struct DOSBase *)OpenLibrary("dos.library", 36);
  52.     if(!DOSBase) cldo(29);
  53. }
  54.  
  55.  
  56. /*
  57. ** Checks the type of character.
  58. */
  59. LONG type(char tkn)
  60. {
  61.     if(tkn >= '0' && tkn <= '9') return(NUMBER);
  62.     if(tkn >= 'a' && tkn <= 'z') return(LLETTER);
  63.     if(tkn >= 'A' && tkn <= 'Z') return(ULETTER);
  64.     if(tkn == '-' || tkn == '+' || tkn == '*' || tkn == '/') return(OTHER);
  65. }
  66.  
  67.  
  68. /*
  69. ** Convert a string into an integer.
  70. */
  71. int conv(char *str)
  72. {
  73.     int pek=0, ret=0;
  74.  
  75.     for(;str[pek] != NULL; pek++)
  76.     {
  77.     ret *= 10;
  78.     ret += (int)str[pek] - (int)'0';
  79.     if(type(str[pek]) != NUMBER) return(-1);
  80.     }
  81.     return(ret);
  82. }
  83.  
  84.  
  85. /*
  86. ** Returns the value from a flag, for example: X50 returns 50
  87. */
  88. int convarg(char *str)
  89. {
  90.     int tmp=1;
  91.  
  92.     if(str[1] == NULL) return(-1);
  93.     if(type(str[1]) != NUMBER) tmp++;
  94.     return(conv(&(str[tmp])));
  95. }
  96.  
  97.  
  98. /*
  99. ** Get active window and screen
  100. */
  101. void getactive()
  102. {
  103.     ULONG lock;
  104.  
  105.     lock=LockIBase(0);
  106.     window = IntuitionBase->ActiveWindow;
  107.     screen = IntuitionBase->ActiveScreen;
  108.     UnlockIBase(lock);
  109. }
  110.  
  111.  
  112. /*
  113. ** Default values
  114. */
  115. void defaultvalues(SHORT *s)
  116. {
  117.     s[0] = window->LeftEdge;
  118.     s[1] = window->TopEdge;
  119.     s[2] = window->Width;
  120.     s[3] = window->Height;
  121.     s[4] = 0;
  122.     s[5] = 0;
  123. }
  124.  
  125.  
  126. /*
  127. ** Screen values
  128. */
  129. void screenvalues(SHORT *s, UBYTE what)
  130. {
  131.     if(what == 0 || what == 5) s[0] = 0;
  132.     if(what == 1 || what == 5) s[1] = 0;
  133.     if(what == 2 || what == 5) s[2] = screen->Width;
  134.     if(what == 3 || what == 5) s[3] = screen->Height;
  135. }
  136.  
  137.  
  138. /*
  139. ** Prints the window status.
  140. */
  141. void windowstatus()
  142. {
  143.     PutStr("\n Window.\n");
  144.     VPrintf(" X-Pos  : %d\n", &(window->LeftEdge));
  145.     VPrintf(" Y-Pos  : %d\n", &(window->TopEdge));
  146.     VPrintf(" Width  : %d\n", &(window->Width));
  147.     VPrintf(" Height : %d\n", &(window->Height));
  148.     VPrintf(" Title  : %s\n", &(window->Title));
  149. }
  150.  
  151.  
  152. /*
  153. ** Prints the screen status.
  154. */
  155. void screenstatus()
  156. {
  157.     LONG    depth;
  158.  
  159.     depth = (LONG)screen->BitMap.Depth;
  160.  
  161.     PutStr("\n Screen.\n");
  162.     VPrintf(" X-Pos  : %d\n", &(screen->LeftEdge));
  163.     VPrintf(" Y-Pos  : %d\n", &(screen->TopEdge));
  164.     VPrintf(" Width  : %d\n", &(screen->Width));
  165.     VPrintf(" Height : %d\n", &(screen->Height));
  166.     VPrintf(" Depth  : %ld\n", &(depth));
  167.     VPrintf(" Title  : %s\n", &(screen->Title));
  168. }
  169.  
  170.  
  171. /*
  172. ** Prints a list of all screens and windows.
  173. */
  174. void viewscreens()
  175. {
  176.     struct Screen *tmpscreen;
  177.     struct Window *tmpwindow;
  178.     ULONG  lock;
  179.  
  180.     lock = LockIBase(0);
  181.     tmpscreen = IntuitionBase->FirstScreen;
  182.     UnlockIBase(lock);
  183.  
  184.     while(tmpscreen != NULL)
  185.     {
  186.     if(tmpscreen == screen) PutStr("*");
  187.     else PutStr(" ");
  188.     VPrintf(" Screen '%s'", &(tmpscreen->Title));
  189.     VPrintf(" at address %ld\n", &(tmpscreen));
  190.     tmpwindow = tmpscreen->FirstWindow;
  191.     while(tmpwindow != NULL)
  192.     {
  193.         if(tmpwindow == window) PutStr("*");
  194.         else PutStr(" ");
  195.         VPrintf("    Window '%s'", &(tmpwindow->Title));
  196.         VPrintf(" at address %ld\n", &(tmpwindow));
  197.         tmpwindow = tmpwindow->NextWindow;
  198.     }
  199.     tmpscreen = tmpscreen->NextScreen;
  200.     }
  201. }
  202.  
  203.  
  204.  
  205. /*
  206. ** Alloc memory for command, and link into list
  207. */
  208. struct Com *alloccom()
  209. {
  210.     Tmp = (struct Com *)AllocVec(sizeof(struct Com), MEMF_PUBLIC | MEMF_CLEAR);
  211.     if(Tmp)
  212.     {
  213.     if(Start == NULL && End == NULL)
  214.     {
  215.         Start = End = Tmp;
  216.         Tmp->Next = NULL;
  217.         Tmp->Prev = NULL;
  218.     }
  219.     else
  220.     {
  221.         End->Next = Tmp;
  222.         Tmp->Prev = End;
  223.         Tmp->Next = NULL;
  224.         End=Tmp;
  225.     }
  226.     return(Tmp);
  227.     }
  228.     return(FALSE);
  229. }
  230.  
  231. /*
  232. ** Frees memory used by command list
  233. */
  234. void freecom()
  235. {
  236.     Tmp = Start;
  237.  
  238.     while(Tmp != NULL)
  239.     {
  240.     Start = Tmp;
  241.     Tmp = Tmp->Next;
  242.     FreeVec(Start);
  243.     }
  244. }
  245.  
  246.  
  247. /*
  248. ** Parses the commands
  249. */
  250. int parsecommands(int ac, char **av)
  251. {
  252.     int x=1, x1=0;
  253.     int t=0;
  254.  
  255.     while(x<ac)
  256.     {
  257.     switch(av[x][0])
  258.     {
  259.         case 'l':
  260.         case 'L':
  261.         loadscript(&(av[x][1]));
  262.         break;
  263.         default:
  264.         t=1;
  265.         Tmp = alloccom();
  266.         if(!Tmp) return(0);
  267.         Tmp->Command = (LONG)av[x][0];
  268.         if(type(Tmp->Command) != LLETTER && type(Tmp->Command) != ULETTER)
  269.         {
  270.             switch(x1)
  271.             {
  272.             case 0: Tmp->Command = 'X'; break;
  273.             case 1: Tmp->Command = 'Y'; break;
  274.             case 2: Tmp->Command = 'W'; break;
  275.             case 3: Tmp->Command = 'H'; break;
  276.             }
  277.             t=0;
  278.             x1++;
  279.         }
  280.         if(type(av[x][t]) != NUMBER)
  281.         {
  282.             Tmp->Arg2 = av[x][t];
  283.         }
  284.         Tmp->Arg = (LONG)convarg(&(av[x][t-1]));
  285.         if(Tmp->Command == 'r' || Tmp->Command == 'R') Tmp->Arg2 = Tmp->Arg;
  286.         break;
  287.     }
  288.     x++;
  289.     }
  290.     return(0);
  291. }
  292.  
  293. /*
  294. ** Loads a script.
  295. */
  296. int loadscript(char *name)
  297. {
  298.     BPTR    lock;
  299.     char    file[80] = "S:";
  300.     int     tmp;
  301.     BPTR    fil;
  302.     char    buffer[120];
  303.     char    temp;
  304.  
  305.     lock = Lock(name, ACCESS_READ);
  306.     if(!lock)
  307.     {
  308.     for(tmp=0; name[tmp] != NULL; file[tmp+2] = name[tmp], tmp++);
  309.     file[tmp+2] = NULL;
  310.     lock = Lock(file, ACCESS_READ);
  311.     if(!lock) return(0);
  312.     name = file;
  313.     }
  314.  
  315.     /* Got a lock */
  316.  
  317.     fil = OpenFromLock(lock);
  318.  
  319.     temp=' ';
  320.  
  321.     while(temp == ' ')
  322.     {
  323.     temp = FGetC(fil);
  324.     if(temp == 0x09 || temp == 0x0a) temp = ' ';
  325.     }
  326.  
  327.     while(temp != -1)
  328.     {
  329.     if(temp == -1) break;
  330.     Tmp = alloccom();
  331.     Tmp->Command = temp;
  332.     tmp=1;
  333.     temp = NULL;
  334.     while(temp != -1 && temp != ' ' &&  temp != 0x09 && temp != 0x0a)
  335.     {
  336.         buffer[tmp++] = temp = FGetC(fil);
  337.     }
  338.     buffer[tmp-1] = NULL;
  339.     if(type(buffer[1]) != NUMBER) Tmp->Arg2 = buffer[1];
  340.     Tmp->Arg = convarg(buffer);
  341.     if(temp == -1) break;
  342.     UnGetC(fil, temp);
  343.     temp=' ';
  344.     while(temp == ' ')
  345.     {
  346.         temp = FGetC(fil);
  347.         if(temp == 0x09 || temp == 0x0a) temp = ' ';
  348.     }
  349.     if(Tmp->Command == 'l' || Tmp->Command == 'L')
  350.     {
  351.         Tmp->Prev->Next = NULL;
  352.         End=End->Prev;
  353.         FreeVec(Tmp);
  354.         loadscript(&(buffer[1]));
  355.     }
  356.     }
  357.     Close(fil);
  358.     UnLock(lock);
  359.     return(0);
  360. }
  361.  
  362.  
  363. /*
  364. ** Frees all but num bitmaps in a window.
  365. */
  366. void freebitmap(int num)
  367. {
  368.     BYTE depth;
  369.     WORD bpr, row;
  370.     LONG *pek;
  371.     int  i;
  372.  
  373.     depth = screen->BitMap.Depth;
  374.     bpr   = screen->BitMap.BytesPerRow;
  375.     row   = screen->BitMap.Rows;
  376.  
  377.     if(num < 1) num = 1;
  378.     if(num > 8) num = 8;
  379.  
  380.     Forbid();
  381.     while(depth > num)
  382.     {
  383.     pek = (LONG *)screen->BitMap.Planes[depth-1];
  384.     for(i=0; i < (bpr*row)/4; i++)
  385.     {
  386.         *pek = 0x00000000;
  387.         pek++;
  388.     }
  389.     FreeMem(screen->BitMap.Planes[depth-1], bpr*row);
  390.     depth--;
  391.     }
  392.     screen->BitMap.Depth = num;
  393.     Permit();
  394. }
  395.  
  396.  
  397. /*
  398. ** Adds bitmaps
  399. */
  400. BOOL addbitmap(int num)
  401. {
  402.     BYTE depth;
  403.     WORD bpr, row;
  404.     PLANEPTR pek;
  405.  
  406.     depth = screen->BitMap.Depth;
  407.     bpr   = screen->BitMap.BytesPerRow;
  408.     row   = screen->BitMap.Rows;
  409.  
  410.     Forbid();
  411.  
  412.     if(num < 1) num = depth+1;
  413.     if(num > 8) num = 8;
  414.  
  415.     while(depth < num)
  416.     {
  417.     pek = (PLANEPTR)AllocMem(bpr*row, MEMF_CHIP | MEMF_CLEAR);
  418.     if(!pek)
  419.     {
  420.         screen->BitMap.Depth = depth;
  421.         Permit();
  422.         return(FALSE);
  423.     }
  424.     screen->BitMap.Planes[depth] = pek;
  425.     depth++;
  426.     }
  427.     screen->BitMap.Depth = depth;
  428.     Permit();
  429.     return(TRUE);
  430. }
  431.  
  432.  
  433. /*
  434. ** Sends an IDCMP_CLOSEWINDOW message to the window.
  435. */
  436. BOOL closewindow()
  437. {
  438.     struct IntuiMessage *imess;
  439.     struct MsgPort *replyport;
  440.  
  441.     if(!(window->IDCMPFlags & IDCMP_CLOSEWINDOW)) return(FALSE);
  442.  
  443.     imess = (struct IntuiMessage *)AllocVec(sizeof(struct IntuiMessage), MEMF_PUBLIC | MEMF_CLEAR);
  444.     if(!imess) return(FALSE);
  445.  
  446.     replyport = (struct MsgPort *)CreateMsgPort();
  447.     if(!replyport) return(FALSE);
  448.  
  449.     imess->ExecMessage.mn_Node.ln_Type    = NT_MESSAGE;
  450.     imess->ExecMessage.mn_ReplyPort    = replyport;
  451.     imess->ExecMessage.mn_Length    = sizeof(struct IntuiMessage);
  452.     imess->Class            = IDCMP_CLOSEWINDOW;
  453.     imess->IDCMPWindow            = window;
  454.  
  455.     Forbid();
  456.     PutMsg(window->UserPort, imess);
  457.     Permit();
  458.  
  459.     WaitPort(replyport);
  460.  
  461.     DeleteMsgPort(replyport);
  462.     FreeVec(imess);
  463.  
  464.     return(TRUE);
  465. }
  466.  
  467.  
  468. void updateposition(int x, SHORT *s)
  469. {
  470.  
  471.     if(x != 2)
  472.     {
  473.     if((s[0] + s[2]) > screen->Width) s[2] = screen->Width - s[0];
  474.     if((s[1] + s[3]) > screen->Height) s[3] = screen->Height - s[1];
  475.     ChangeWindowBox(window, s[0], s[1], s[2], s[3]);
  476.     }
  477.     if(x != 1) MoveScreen(screen, s[4], s[5]);
  478. }
  479.  
  480.  
  481. /*
  482. ** Private command.  This function will NEVER be a part of a release.
  483. ** This function is for authors use ONLY. Compile and use this function
  484. ** at your own risk.
  485. */
  486. #ifndef NOPRIV
  487. BOOL privatecommand(LONG arg, LONG arg2)
  488. {
  489.     struct Screen *s, *d;
  490.     char *t;
  491.     int de;
  492.  
  493.     s = screen;
  494.     d = (struct Screen *)arg;
  495.  
  496.     de = s->BitMap.Depth;
  497.  
  498.     while(de)
  499.     {
  500.     t = s->BitMap.Planes[de-1];
  501.     s->BitMap.Planes[de-1] = d->BitMap.Planes[de-1];
  502.     d->BitMap.Planes[de-1] = t;
  503.     de--;
  504.     }
  505.  
  506.     return(TRUE);
  507. }
  508. #endif
  509.  
  510.  
  511. /*
  512. ** Main, guess why...
  513. */
  514. main(int ac, char **av)
  515. {
  516.     SHORT  s[6];
  517.     BOOL   upd=FALSE, mvscr = FALSE;
  518.     LONG   tal=0;
  519.     struct Window *tmpwin;
  520.     struct Com dummy;
  521.  
  522.     opup();
  523.  
  524.     getactive();
  525.  
  526.     if(ac != 1)
  527.     {
  528.     defaultvalues(s);
  529.     }
  530.     else
  531.     {
  532.     screenvalues(s, 5);
  533.     upd=TRUE;
  534.     }
  535.  
  536.     parsecommands(ac, av);
  537.  
  538.     Tmp=Start;
  539.  
  540.     dummy.Next = Start;
  541.  
  542.     while(Tmp)
  543.     {
  544. #ifdef PRCOM
  545.     printf("\n Command : %c\n", (char)Tmp->Command);
  546.     printf(" Arg     : %d\n", Tmp->Arg);
  547.     printf(" Arg2    : %d\n", Tmp->Arg2);
  548.     printf(" Screen  : %d\n", screen);
  549.     printf(" Window  : %d\n\n", window);
  550. #endif
  551.     switch(Tmp->Command)
  552.     {
  553. #ifndef NOPRIV
  554.         case 'p':
  555.         privatecommand(Tmp->Arg, Tmp->Arg2);
  556.         break;
  557. #endif
  558.         case 'u':                       /* COMMAND:     Update      */
  559.         case 'U':                       /* SYNTAX:      U[w/s]      */
  560.         switch(Tmp->Arg2)
  561.         {
  562.             case 'W':
  563.             case 'w':
  564.             updateposition(1, s);
  565.             break;
  566.             case 's':
  567.             case 'S':
  568.             updateposition(2, s);
  569.             break;
  570.             default:
  571.             updateposition(0, s);
  572.             break;
  573.         }
  574.         break;
  575.  
  576.         case 'E':                       /* COMMAND:     Left        */
  577.         case 'e':                       /* SYNTAX:      L[+|-]n     */
  578.         if(Tmp->Arg == -1) break;
  579.         switch(Tmp->Arg2)
  580.         {
  581.             case '-':
  582.             s[4] = s[4] - Tmp->Arg;
  583.             break;
  584.             case '+':
  585.             s[4] = s[4] + Tmp->Arg;
  586.             break;
  587.             default:
  588.             s[4] = Tmp->Arg - screen->LeftEdge;
  589.             break;
  590.         }
  591.         mvscr = TRUE;
  592.         break;
  593.  
  594.         case 'T':                       /* COMMAND:     Top         */
  595.         case 't':                       /* SYNTAX:      T[+|-]n     */
  596.         if(Tmp->Arg == -1) break;
  597.         switch(Tmp->Arg2)
  598.         {
  599.             case '-':
  600.             s[5] -= Tmp->Arg;
  601.             break;
  602.             case '+':
  603.             s[5] += Tmp->Arg;
  604.             break;
  605.             default:
  606.             s[5] = Tmp->Arg - screen->TopEdge;
  607.             break;
  608.         }
  609.         mvscr = TRUE;
  610.         break;
  611.  
  612.         case 'k':                       /* COMMAND:     Kill        */
  613.         case 'K':                       /* SYNTAX:      Kn          */
  614.         if(Tmp->Arg != -1)
  615.         {
  616.             tmpwin = window;
  617.             window = (struct Window *)Tmp->Arg;
  618.             closewindow();
  619.             window = tmpwin;
  620.         }
  621.         else closewindow();
  622.         break;
  623.         case 'm':                       /* COMMAND:     bitMap      */
  624.         case 'M':                       /* SYNTAX:      M[+|-]      */
  625.         if(Tmp->Arg2 == '-')
  626.         {
  627.             freebitmap(Tmp->Arg);
  628.         }
  629.         else if(Tmp->Arg2 == '+')
  630.         {
  631.             addbitmap(Tmp->Arg);
  632.         }
  633.         break;
  634.  
  635.         case 'c':                       /* COMMAND:     Change      */
  636.         case 'C':                       /* SYNTAX:      C[W|S|R]n   */
  637.         switch(Tmp->Arg2)
  638.         {
  639.             case 'r':
  640.             case 'R':
  641.             getactive();
  642.             break;
  643.             case 's':
  644.             case 'S':
  645.             if(Tmp->Arg == -1) break;
  646.             screen = (struct Screen *)Tmp->Arg;
  647.             break;
  648.             case 'w':
  649.             case 'W':
  650.             if(Tmp->Arg == -1) break;
  651.             window = (struct Window *)Tmp->Arg;
  652.             break;
  653.         }
  654.         break;
  655.  
  656.         case 'a':                       /* COMMAND:     Activate    */
  657.         case 'A':                       /* SYNTAX:      An          */
  658.         if(Tmp->Arg < 1) break;
  659.         tmpwin=window;
  660.         while(tmpwin == window)
  661.         {
  662.             Delay(Tmp->Arg);
  663.             getactive();
  664.         }
  665.         defaultvalues(s);
  666.         break;
  667.  
  668.         case 'r':                       /* COMMAND:     Repeat      */
  669.         case 'R':                       /* SYNTAX:      Rn          */
  670.         if(Tmp->Arg < 0) break;
  671.         if(Tmp->Arg == 0 || Tmp->Arg2 == 0) Tmp = &dummy;
  672.         else
  673.         {
  674.             Tmp->Arg--;
  675.             if(Tmp->Arg != 0) Tmp = &dummy;
  676.             else Tmp->Arg = Tmp->Arg2;
  677.         }
  678.         break;
  679.  
  680.         case 'd':                       /* COMMAND:     Delay       */
  681.         case 'D':                       /* SYNTAX:      Dn          */
  682.         if(Tmp->Arg > 0) Delay(Tmp->Arg);
  683.         getactive();
  684.         defaultvalues(s);
  685.         break;
  686.  
  687.         case 'v':
  688.         case 'V':
  689.         viewscreens();
  690.         break;
  691.  
  692.         case 'f':                       /* COMMAND:     Front       */
  693.         case 'F':                       /* SYNTAX:      F           */
  694.         if(Tmp->Arg != -1)
  695.         {
  696.             WindowToFront((struct Window *)Tmp->Arg);
  697.         }
  698.         else WindowToFront(window);
  699.         break;
  700.  
  701.  
  702.         case 'b':                       /* COMMAND:     Back        */
  703.         case 'B':                       /* SYNTAX:      B           */
  704.         if(Tmp->Arg != -1)
  705.         {
  706.             WindowToBack((struct Window *)Tmp->Arg);
  707.         }
  708.         else WindowToBack(window);
  709.         break;
  710.  
  711.         case 'z':                       /* COMMAND:     Zip         */
  712.         case 'Z':                       /* SYNTAX:      Z           */
  713.         if(Tmp->Arg != -1)
  714.         {
  715.             ZipWindow((struct Window *)Tmp->Arg);
  716.         }
  717.         else ZipWindow(window);
  718.         break;
  719.  
  720.         case 'i':                       /* COMMAND:     Info        */
  721.         case 'I':                       /* SYNTAX:      I[S|W]      */
  722.         switch(Tmp->Arg2)
  723.         {
  724.             case 's':
  725.             case 'S':
  726.             screenstatus();
  727.             break;
  728.             case 'w':
  729.             case 'W':
  730.             windowstatus();
  731.             break;
  732.             default:
  733.             screenstatus();
  734.             windowstatus();
  735.             break;
  736.         }
  737.         break;
  738.  
  739.         case 'h':                       /* COMMAND:     Height      */
  740.         case 'H':                       /* SYNTAX:  H[+|-|/|*|S]n   */
  741.         tal++;
  742.  
  743.         case 'w':                       /* COMMAND:     Width       */
  744.         case 'W':                       /* SYNTAX:  W[+|-|/|*|S]n   */
  745.         tal++;
  746.  
  747.         case 'y':                       /* COMMAND:     Y position  */
  748.         case 'Y':                       /* SYNTAX:  Y[+|-|/|*|S]n   */
  749.         tal++;
  750.  
  751.         case 'x':                       /* COMMAND:     X position  */
  752.         case 'X':                       /* SYNTAX:   X[+|-|/|*|S]n  */
  753.  
  754.         if(Tmp->Arg2 == 's' || Tmp->Arg2 == 'S') screenvalues(s, tal);
  755.         else if(Tmp->Arg2 == '-') s[tal] -= Tmp->Arg;
  756.         else if(Tmp->Arg2 == '+') s[tal] += Tmp->Arg;
  757.         else if(Tmp->Arg2 == '/') s[tal] /= Tmp->Arg;
  758.         else if(Tmp->Arg2 == '*') s[tal] *= Tmp->Arg;
  759.         else s[tal] = Tmp->Arg;
  760.         upd=1;
  761.         break;
  762.     }
  763.     tal=0;
  764.     Tmp = Tmp->Next;
  765.     }
  766.  
  767.     if(upd) updateposition(1, s);
  768.     if(mvscr) updateposition(2, s);
  769.  
  770.     freecom();
  771.  
  772.     cldo(0);
  773. }
  774.